import logging
import sqlite3 as sq
import time

import aiofiles
from aiogram import types

import client
import client_kb
from config import load_config
from keyboards import admin_kb

from create_bot import bot
from aiocryptopay import AioCryptoPay

config = load_config()
Admins = config.tg_bot.admin_ids

logger = logging.getLogger(__name__)


def sql_start():
    global base, cur
    base = sq.connect("ancets.db")
    cur = base.cursor()
    if base:
        logger.info("Data base is connected")

    base.execute(
        "CREATE TABLE IF NOT EXISTS users"
        "(id INT, promo TEXT, country TEXT, balance TEXT NOT NULL DEFAULT 0.00, "
        'time_sub TEXT NOT NULL DEFAULT 0, PRIMARY KEY("id"))'
    )
    base.commit()

    base.execute(
        'CREATE TABLE IF NOT EXISTS "CHECK" ("user_id" INTEGER NOT NULL, '
        '"bill_id" TEXT NOT NULL, "country" TEXT NOT NULL, "promo_name" TEXT, PRIMARY KEY("bill_id") )'
    )
    base.commit()

    base.execute(
        'CREATE TABLE IF NOT EXISTS "CHECK_CRYPTO" ("user_id" INTEGER NOT NULL, '
        '"bill_id" TEXT NOT NULL, "country" TEXT NOT NULL, "promo_name" TEXT, PRIMARY KEY("bill_id") )'
    )
    base.commit()

    base.execute(
        'CREATE TABLE IF NOT EXISTS "CHECK_BALANCE" ("user_id" INTEGER NOT NULL, '
        '"bill_id" TEXT NOT NULL, "summa" TEXT NOT NULL, PRIMARY KEY("bill_id") )'
    )
    base.commit()

    base.execute(
        'CREATE TABLE IF NOT EXISTS "CHECK_BALANCE_CRYPTO" ("user_id" INTEGER NOT NULL, '
        '"bill_id" TEXT NOT NULL, "summa" TEXT NOT NULL, PRIMARY KEY("bill_id") )'
    )
    base.commit()

    base.execute(
        'CREATE TABLE IF NOT EXISTS "CHECK_SUBSCRIPTION" ("user_id" INTEGER NOT NULL, '
        '"bill_id" TEXT NOT NULL, "type_sub" TEXT NOT NULL, PRIMARY KEY("bill_id") )'
    )
    base.commit()

    base.execute(
        'CREATE TABLE IF NOT EXISTS "promo" ( "id" INTEGER NOT NULL, "name" TEXT UNIQUE, "discount" INTEGER, '
        '"sale" INTEGER DEFAULT 0, "ar" INTEGER DEFAULT 0, "uk" INTEGER DEFAULT 0, '
        '"uk_bill" INTEGER DEFAULT 0, "br_bill" INTEGER DEFAULT 0, "br_id" INTEGER DEFAULT 0, "it_bill" '
        'INTEGER DEFAULT 0, "it_id" INTEGER DEFAULT 0, "mx_bill" INTEGER DEFAULT 0, "it_dl" INTEGER DEFAULT 0,'
        '"es_pass" INTEGER DEFAULT 0,'
        '"es_id" INTEGER DEFAULT 0,'
        '"ar_pass" INTEGER DEFAULT 0,'
        '"mx_pass" INTEGER DEFAULT 0,'
        '"ar_id" INTEGER DEFAULT 0,'
        '"br_dl" INTEGER DEFAULT 0,'
        '"br_pass" INTEGER DEFAULT 0,'
        '"kz_pass" INTEGER DEFAULT 0,'
        '"kz_id_new" INTEGER DEFAULT 0,'
        '"est_id" INTEGER DEFAULT 0,'
        '"kz_id_old" INTEGER DEFAULT 0,'
        '"de_bill" INTEGER DEFAULT 0,'
        '"est_bill" INTEGER DEFAULT 0,'
        '"de_id" INTEGER DEFAULT 0,'
        'PRIMARY KEY("id" AUTOINCREMENT) );'
    )


async def sql_command_check(message):
    user_id = message.from_user.id
    country = cur.execute(
        "SELECT country FROM 'users' WHERE id = ?", (user_id,)
    ).fetchone()
    logger.info(country[0])


async def add_check_subscription(user_id, bill_id, type_sub):
    cur.execute(
        "INSERT INTO 'CHECK_SUBSCRIPTION' ('user_id', 'bill_id', 'type_sub') VALUES (?,?,?)",
        (user_id, bill_id, type_sub),
    )
    base.commit()


async def get_check_subscription(bill_id):
    result = cur.execute(
        "SELECT * FROM 'CHECK_SUBSCRIPTION' WHERE bill_id = ?", (bill_id,)
    ).fetchmany(1)
    if not bool(len(result)):
        return False
    return result[0]


async def add_check_qiwi(user_id, bill_id, amountq, promo_name):
    cur.execute(
        "INSERT INTO 'CHECK' ('user_id', 'bill_id', 'country', 'promo_name') VALUES (?,?,?,?)",
        (user_id, bill_id, amountq, promo_name),
    )
    base.commit()


async def add_check_crypto(user_id, bill_id, amountq, promo_name):
    cur.execute(
        "INSERT INTO 'CHECK_CRYPTO' ('user_id', 'bill_id', 'country', 'promo_name') VALUES (?,?,?,?)",
        (user_id, bill_id, amountq, promo_name),
    )
    base.commit()


async def add_check_balance_qiwi(user_id, bill_id, price):
    cur.execute(
        "INSERT INTO 'CHECK_BALANCE' ('user_id', 'bill_id', 'summa') VALUES (?,?,?)",
        (user_id, bill_id, price),
    )
    base.commit()


async def get_check_balance_qiwi(bill_id):
    result = cur.execute(
        "SELECT * FROM 'CHECK_BALANCE' WHERE bill_id = ?", (bill_id,)
    ).fetchmany(1)
    if not bool(len(result)):
        return False
    return result[0]


async def add_check_balance_crypto(user_id, bill_id, price):
    cur.execute(
        "INSERT INTO 'CHECK_BALANCE_CRYPTO' ('user_id', 'bill_id', 'summa') VALUES (?,?,?)",
        (user_id, bill_id, price),
    )
    base.commit()


async def get_check_balance_crypto(bill_id):
    result = cur.execute(
        "SELECT * FROM 'CHECK_BALANCE_CRYPTO' WHERE bill_id = ?", (bill_id,)
    ).fetchmany(1)
    if not bool(len(result)):
        return False
    return result[0]


async def get_check(bill_id):
    result = cur.execute(
        "SELECT * FROM 'CHECK' WHERE bill_id = ?", (bill_id,)
    ).fetchmany(1)
    if not bool(len(result)):
        return False
    return result[0]


async def get_check_crypto(bill_id):
    result = cur.execute(
        "SELECT * FROM 'CHECK_CRYPTO' WHERE bill_id = ?", (bill_id,)
    ).fetchmany(1)
    if not bool(len(result)):
        return False
    return result[0]


async def check_user_in_db(user_id):
    me = cur.execute("SELECT id FROM users WHERE id = ?", (user_id,)).fetchall()
    if len(me) == 0:
        cur.execute("INSERT INTO 'users' ('id') VALUES (?)", (user_id,))
        base.commit()


async def sql_check_user(user_id):
    me = cur.execute("SELECT id FROM users WHERE id = ?", (user_id,)).fetchall()
    if len(me) == 0:
        cur.execute("INSERT INTO 'users' ('id') VALUES (?)", (user_id,))
        base.commit()


async def get_user_balance(user_id):
    balance = cur.execute(
        "SELECT balance FROM users WHERE id = ?", (user_id,)
    ).fetchone()[0]
    return float(balance)


async def sql_check_what_money_to_sub(user_id, sub_type):
    check = cur.execute("SELECT balance FROM users WHERE id = ?", (user_id,)).fetchone()
    if sub_type == "week":
        price = float(config.payment.price_sub_week)
    else:
        price = float(config.payment.price_sub_month)
    if float(check[0]) >= float(price):
        return True
    else:
        return False


async def get_user_details_from_db(user_id):
    """
    Получение инфомраци о балансе и активной подписке пользователя
    :param user_id: Telegram-id
    :return: кортеж из значений баланса и времени подписки
    """
    check = cur.execute(
        "SELECT balance, time_sub FROM users WHERE id = ?", (user_id,)
    ).fetchone()
    time_now = int(time.time())
    middle_time = int(check[1]) - time_now
    return check[0], middle_time


async def sql_check_sub(user_id):
    check = cur.execute(
        "SELECT time_sub FROM users WHERE id = ?", (user_id,)
    ).fetchone()
    time_now = int(time.time())
    middle_time = int(check[0]) - time_now
    if middle_time <= 0:
        return False
    else:
        return True


async def sql_give_sub_on_balance(user_id, price, type_sub):
    balance = cur.execute(
        "SELECT balance FROM 'users' WHERE id = ?", (user_id,)
    ).fetchone()[0]
    new_balance = float(balance) - float(price)
    cur.execute(
        "UPDATE users SET balance = ? WHERE id = ?",
        (
            new_balance,
            user_id,
        ),
    )
    base.commit()
    if type_sub == "mounth":
        time_sub = int(time.time()) + 31 * 24 * 60 * 60
        cur.execute(
            "UPDATE users SET time_sub = ? WHERE id = ?",
            (
                time_sub,
                user_id,
            ),
        )
        base.commit()
        await bot.send_message(
            user_id,
            f"Подписка на месяц успешно подключена",
            reply_markup=client_kb.kb_choice,
        )
        try:
            await bot.send_message(
                Admins[0], f"Совершена покупка подписки на месяц с баланса лк"
            )
        except Exception as ex:
            logger.exception("Ошибка при рассылке админу", ex)
    else:
        time_sub = int(time.time()) + 7 * 24 * 60 * 60
        cur.execute(
            "UPDATE users SET time_sub = ? WHERE id = ?",
            (
                time_sub,
                user_id,
            ),
        )
        base.commit()
        await bot.send_message(
            user_id,
            f"Подписка на неделю успешно подключена",
            reply_markup=client_kb.kb_choice,
        )
        try:
            await bot.send_message(
                Admins[0], f"Совершена покупка подписки на неделю с баланса лк"
            )
        except Exception as ex:
            logger.exception("Ошибка при рассылке админу", ex)


async def sql_give_subscription(user_id, bill):
    type_sub = cur.execute(
        "SELECT type_sub FROM 'CHECK_SUBSCRIPTION' WHERE bill_id = ?", (bill,)
    ).fetchone()[0]
    if type_sub == "mounth":
        time_sub = int(time.time()) + 31 * 24 * 60 * 60
        cur.execute(
            "UPDATE users SET time_sub = ? WHERE id = ?",
            (
                time_sub,
                user_id,
            ),
        )
        base.commit()
        await bot.send_message(
            user_id,
            f"Подписка на месяц успешно подключена",
            reply_markup=client_kb.kb_choice,
        )
        try:
            await bot.send_message(Admins[0], f"Совершена покупка подписки на месяц")
        except Exception as ex:
            logger.exception("Ошибка при рассылке админу", ex)
    else:
        time_sub = int(time.time()) + 7 * 24 * 60 * 60
        cur.execute(
            "UPDATE users SET time_sub = ? WHERE id = ?",
            (
                time_sub,
                user_id,
            ),
        )
        base.commit()
        await bot.send_message(
            user_id,
            f"Подписка на неделю успешно подключена",
            reply_markup=client_kb.kb_choice,
        )
        try:
            await bot.send_message(Admins[0], f"Совершена покупка подписки на неделю")
        except Exception as ex:
            logger.exception("Ошибка при рассылке админу", ex)


async def sql_give_balance_qiwi(user_id, bill):
    summa = cur.execute(
        "SELECT summa FROM 'CHECK_BALANCE' WHERE bill_id = ?", (bill,)
    ).fetchone()[0]
    balance = cur.execute(
        "SELECT balance FROM 'users' WHERE id = ?", (user_id,)
    ).fetchone()[0]
    new_balance = float(balance) + float(summa)
    cur.execute(
        "UPDATE users SET balance = ? WHERE id = ?",
        (
            new_balance,
            user_id,
        ),
    )
    base.commit()
    await bot.send_message(
        user_id,
        f"Пополнение прошло успешно, теперь ваш баланс составляет {new_balance} руб.",
        reply_markup=client_kb.kb_choice,
    )
    try:
        await bot.send_message(Admins[0], f"Совершено пополнение баланса с киви")
    except Exception as ex:
        logger.exception("Ошибка при рассылке админу", ex)


async def sql_give_balance_crypto(user_id, bill, crypto: AioCryptoPay):
    summa = cur.execute(
        "SELECT summa FROM 'CHECK_BALANCE_CRYPTO' WHERE bill_id = ?", (bill,)
    ).fetchone()[0]
    check = await crypto.get_exchange_rates()
    usdt_rub_rate = ""
    for rate in check:
        if rate.source == "USDT" and rate.target == "RUB":
            usdt_rub_rate = rate.rate
            break
    summa_rub = float(summa) * float(usdt_rub_rate)
    balance = cur.execute(
        "SELECT balance FROM 'users' WHERE id = ?", (user_id,)
    ).fetchone()[0]
    new_balance = float(balance) + float(summa_rub)
    cur.execute(
        "UPDATE users SET balance = ? WHERE id = ?",
        (
            new_balance,
            user_id,
        ),
    )
    base.commit()
    await bot.send_message(
        user_id,
        f"Пополнение прошло успешно, теперь ваш баланс составляет {round(new_balance, 1)} руб.",
        reply_markup=client_kb.kb_choice,
    )
    try:
        user = await bot.get_chat(user_id)
        await bot.send_message(
            Admins[0],
            f'Совершено пополнение баланса криптой на {round(new_balance, 1)} руб. От {user["first_name"]} {user["last_name"]}\nID:{user_id}',
        )
    except Exception as ex:
        logger.exception("Ошибка при рассылке админу", ex)


async def sql_add_country_user(user_id, country):
    try:
        cur.execute(
            "UPDATE users SET country = ? WHERE id = ?",
            (
                country,
                user_id,
            ),
        )
        base.commit()
    except Exception as ex:
        logger.exception("country в юзеры ошибка ", ex)


async def sql_command_check_promo(message, state, promo):
    user_id = message.from_user.id
    if promo == "Продолжить без промокода":
        async with state.proxy() as data:
            country = data["pay_country"]
            promo_discount = 0
            promo_name = "отсутствует"
            return await client.choise_pay(
                user_id, country, promo_discount, state, promo_name
            )
            # await client.top_up(message, state, country, promo_discount, promo_name)
    async with state.proxy() as data:
        country = data["pay_country"]
        check_promo = cur.execute(
            "SELECT * FROM promo WHERE name = ?", (promo,)
        ).fetchone()
        if check_promo is None:
            kb = types.ReplyKeyboardMarkup(resize_keyboard=True)
            kb.add(types.KeyboardButton(text="Продолжить без промокода"))
            return await message.answer(
                "Промокод не найден, попробуйте ещё раз. Или продолжайте без промокода.",
                reply_markup=kb,
            )
            # try:
            #     cur.execute('UPDATE users SET promo = ? WHERE id = ?', (promo, user_id,))
            #     base.commit()
            # except Exception as ex:
            #     print('Промо в юзеры ошибка ', ex)
            # promo_discount = 0
            # promo_name = 'отсутствует'
            # await client.choise_pay(user_id, country, promo_discount, state, promo_name)
            # # await client.top_up(message, state, country, promo_discount, promo_name)
        else:
            try:
                cur.execute(
                    "UPDATE users SET promo = ? WHERE id = ?",
                    (
                        promo,
                        user_id,
                    ),
                )
                base.commit()
            except Exception as ex:
                logger.exception("Промо в юзеры ошибка ", ex)
            promo_name = promo
            if int(check_promo[2]) == 100:
                await state.finish()
                await sql_give_pasp_chip(user_id, country, promo_name)
            else:
                promo_discount = int(check_promo[2])
                await client.choise_pay(
                    user_id, country, promo_discount, state, promo_name
                )
                # await client.top_up(message, state, country, promo_discount, promo_name)


async def sql_give_doc_from_balance(user_id, country, promo_name, price_doc):
    logger.info("sql_give_doc_from_balance:   ", country, promo_name, price_doc)
    balance = cur.execute(
        "SELECT balance FROM 'users' WHERE id = ?", (user_id,)
    ).fetchone()[0]
    new_balance = float(balance) - float(price_doc)
    cur.execute(
        "UPDATE users SET balance = ? WHERE id = ?",
        (
            new_balance,
            user_id,
        ),
    )
    base.commit()
    if promo_name != "отсутствует":
        promo_promo = cur.execute(
            "SELECT sale, ar, uk, uk_bill, mx_bill, br_bill, br_id, it_id FROM promo WHERE name = ?",
            (promo_name,),
        ).fetchone()
        kol_sale = int(promo_promo[0]) + 1
        if country == "ar":
            kol = int(promo_promo[1]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, ar = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    promo_name,
                ),
            )
            base.commit()
        elif country == "uk":
            kol = int(promo_promo[2]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, uk = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/uk_pass/photo_usr/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/uk_pass/photo_usr/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "uk_bill":
            kol = int(promo_promo[3]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, uk_bill = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/uk_pass/{country}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "br_bill":
            kol = int(promo_promo[4]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, br_bill = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/{country}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "br_id":
            kol = int(promo_promo[5]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, br_id = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/{country}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "it_bill":
            kol = int(promo_promo[6]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, it_bill = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0], f"Произошла ошибка при отправке фото после покупки"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "de_bill":
            kol = int(promo_promo[6]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, de_bill = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0], f"Произошла ошибка при отправке фото после покупки"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "mx_pass":
            cur.execute(
                "UPDATE promo SET sale = ?, mx_pass = mx_pass + 1 WHERE name = ?",
                (
                    kol_sale,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/mx/mx_pass/photo_usr/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/mx/mx_pass/photo_usr/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото MX PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото MX PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "mx_bill":
            kol = int(promo_promo[6]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, mx_bill = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/mx_bill/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0], f"Произошла ошибка при отправке фото после покупки"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "it_id":
            kol = int(promo_promo[6]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, it_id = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "it_dl":
            cur.execute(
                "UPDATE promo SET sale = ?, it_dl = id_dl + 1 WHERE name = ?",
                (
                    kol_sale,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото DL",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "es_pass":
            cur.execute(
                "UPDATE promo SET sale = ?, es_pass = es_pass + 1 WHERE name = ?",
                (
                    kol_sale,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/es/photo_usr/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/es/photo_usr/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото ES PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото ES PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "de_id":
            cur.execute(
                "UPDATE promo SET sale = ?, de_id = de_id + 1 WHERE name = ?",
                (
                    kol_sale,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/de_id/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото DE ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото DE ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "est_bill":
            cur.execute(
                "UPDATE promo SET sale = ?, est_bill = est_bill + 1 WHERE name = ?",
                (
                    kol_sale,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/estonia_bill/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото EST BILL",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото EST BILL после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "est_id":
            cur.execute(
                "UPDATE promo SET sale = ?, est_id = est_id + 1 WHERE name = ?",
                (
                    kol_sale,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/estonia_id/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото EST ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото EST ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "kz_id_new":
            cur.execute(
                "UPDATE promo SET sale = ?, kz_id_new = kz_id_new + 1 WHERE name = ?",
                (
                    kol_sale,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/kz/kz_id_new/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "kz_pass":
            cur.execute(
                "UPDATE promo SET sale = ?, kz_pass = kz_pass + 1 WHERE name = ?",
                (
                    kol_sale,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/kz/kz_passport/photo_usr/{user_id}_completed.png",
                        "rb",
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/kz/kz_passport/photo_usr/{user_id}_completed.jpg",
                        "rb",
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "ar_id":
            cur.execute(
                "UPDATE promo SET sale = ?, ar_id = ar_id + 1 WHERE name = ?",
                (
                    kol_sale,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/ar/ar_id/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото AR ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото AR ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "ar_pass":
            cur.execute(
                "UPDATE promo SET sale = ?, ar_pass = ar_pass + 1 WHERE name = ?",
                (
                    kol_sale,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/ar/ar_pass/photo_usr/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/ar/ar_pass/photo_usr/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото AR PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото AR PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "br_pass":
            cur.execute(
                "UPDATE promo SET sale = ?, br_pass = br_pass + 1 WHERE name = ?",
                (
                    kol_sale,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/br_pass/br_passport/photo_usr/{user_id}_completed.jpg",
                        "rb",
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/br_pass/br_passport/photo_usr/{user_id}_completed.png",
                        "rb",
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото BR PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото BR PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "br_dl":
            cur.execute(
                "UPDATE promo SET sale = ?, br_dl = br_dl + 1 WHERE name = ?",
                (
                    kol_sale,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/br_dl/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото BR DL",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото BR DL после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "es_id":
            cur.execute(
                "UPDATE promo SET sale = ?, es_pid = es_id + 1 WHERE name = ?",
                (
                    kol_sale,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/es/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото ES PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото ES ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "kz_id_old":
            cur.execute(
                "UPDATE promo SET sale = ?, kz_id_old = kz_id_old + 1 WHERE name = ?",
                (
                    kol_sale,
                    promo_name,
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/kz/kz_id_old/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ ID OLD",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ_ID_old после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        else:
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country}_pass/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex, 2)
                logger.info(country)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
    else:
        if country == "uk_bill":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/uk_pass/{country}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "uk":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/uk_pass/photo_usr/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/uk_pass/photo_usr/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "br_bill":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/{country}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "br_id":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/{country}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "it_bill":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0], f"Произошла ошибка при отправке фото после покупки"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "mx_pass":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/mx/mx_pass/photo_usr/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/mx/mx_pass/photo_usr/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото MX PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото MX PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "mx_bill":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/mx_bill/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0], f"Произошла ошибка при отправке фото после покупки"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "it_id":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "it_dl":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото DL",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "es_pass":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/es/photo_usr/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/es/photo_usr/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото ES PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото ES PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "de_id":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/de_id/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото DE ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото DE ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "est_bill":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/estonia_bill/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото EST BILL",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото EST BILL после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "est_id":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/estonia_id/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото EST ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото EST ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "kz_id_new":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/kz/kz_id_new/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "kz_pass":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/kz/kz_passport/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/kz/kz_passport/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "ar_id":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/ar/ar_id/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото AR ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото AR ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "ar_pass":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/ar/ar_pass/photo_usr/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/ar/ar_pass/photo_usr/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото AR PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото AR PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country == "br_pass":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/br_pass/br_passport/photo_usr/{user_id}_completed.jpg",
                        "rb",
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/br_pass/br_passport/photo_usr/{user_id}_completed.png",
                        "rb",
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)

            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото BR PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото BR PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "br_dl":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/br_dl/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото BR DL",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото BR DL после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "es_id":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/es/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото ES ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото ES ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "kz_id_old":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/kz/kz_id_old/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ ID OLD",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ ID OLD после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country == "de_bill":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/de_bill/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото DE BILL",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото DE BILL после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        else:
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country}_pass/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex, 1)
                logger.info(country)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)


async def sql_give_pasp(user_id, bill, pay):
    if pay == "crypto":
        amnt = cur.execute(
            "SELECT country, promo_name FROM 'CHECK_CRYPTO' WHERE bill_id = ?", (bill,)
        ).fetchmany(1)
    else:
        amnt = cur.execute(
            "SELECT country, promo_name FROM 'CHECK' WHERE bill_id = ?", (bill,)
        ).fetchmany(1)
    logger.info(amnt, "-----")
    country = cur.execute(
        "SELECT country FROM 'users' WHERE id = ?", (user_id,)
    ).fetchone()
    if amnt[0][1] != "отсутствует":
        promo_promo = cur.execute(
            "SELECT sale, ar, uk, uk_bill, br_bill, br_id, mx_pass, mx_bill FROM promo WHERE name = ?",
            (amnt[0][1],),
        ).fetchone()
        kol_sale = int(promo_promo[0]) + 1
        if amnt[0][0] == "ar":
            kol = int(promo_promo[1]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, ar = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    amnt[0][1],
                ),
            )
            base.commit()
        elif amnt[0][0] == "uk":
            kol = int(promo_promo[2]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, uk = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    amnt[0][1],
                ),
            )
            base.commit()
            try:
                try:
                    await bot.send_message(user_id, "Фото отправляется, ожидайте")
                    async with aiofiles.open(
                        f"./files/uk_pass/photo_usr/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0],
                            f"Совершена покупка, {country[0]}, ({amnt[0][1]})",
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    await bot.send_message(user_id, "Фото отправляется, ожидайте")
                    async with aiofiles.open(
                        f"./files/uk_pass/photo_usr/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0],
                            f"Совершена покупка, {country[0]}, ({amnt[0][1]})",
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif amnt[0][0] == "uk_bill":
            kol = int(promo_promo[3]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, uk_bill = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    amnt[0][1],
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/uk_pass/{country[0]}/photo_usr/{user_id}_completed.png",
                    "rb",
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({amnt[0][1]})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif amnt[0][0] == "br_bill":
            kol = int(promo_promo[4]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, br_bill = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    amnt[0][1],
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/{country[0]}/photo_usr/{user_id}_completed.png",
                    "rb",
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({amnt[0][1]})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif amnt[0][0] == "it_bill":
            kol = int(promo_promo[4]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, it_bill = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    amnt[0][1],
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country[0]}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({amnt[0][1]})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0], f"Произошла ошибка при отправке фото после покупки"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif amnt[0][0] == "de_bill":
            kol = int(promo_promo[4]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, de_bill = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    amnt[0][1],
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country[0]}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({amnt[0][1]})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0], f"Произошла ошибка при отправке фото после покупки"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif amnt[0][0] == "mx_pass":
            kol = int(promo_promo[4]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, mx_pass = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    amnt[0][1],
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/mx/mx_pass/photo_usr/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0],
                            f"Совершена покупка, {country[0]}, ({amnt[0][1]})",
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/mx/mx_pass/photo_usr/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0],
                            f"Совершена покупка, {country[0]}, ({amnt[0][1]})",
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0], f"Произошла ошибка при отправке фото после покупки"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif amnt[0][0] == "mx_bill":
            kol = int(promo_promo[4]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, mx_bill = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    amnt[0][1],
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/mx_bill/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({amnt[0][1]})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0], f"Произошла ошибка при отправке фото после покупки"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif amnt[0][0] == "it_id":
            kol = int(promo_promo[4]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, it_id = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    amnt[0][1],
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{amnt[0][0]}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {amnt[0][0]}, ({amnt[0][1]})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif amnt[0][0] == "it_dl":
            cur.execute(
                "UPDATE promo SET sale = ?, it_dl = it_dl + 1 WHERE name = ?",
                (
                    kol_sale,
                    amnt[0][1],
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{amnt[0][0]}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {amnt[0][0]}, ({amnt[0][1]})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото DL",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото DL после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif amnt[0][0] == "br_dl":
            cur.execute(
                "UPDATE promo SET sale = ?, br_dl = br_dl + 1 WHERE name = ?",
                (
                    kol_sale,
                    amnt[0][1],
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/br_dl/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {amnt[0][0]}, ({amnt[0][1]})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото ES PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото ES PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif amnt[0][0] == "es_id":
            cur.execute(
                "UPDATE promo SET sale = ?, es_id = es_id + 1 WHERE name = ?",
                (
                    kol_sale,
                    amnt[0][1],
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/es/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {amnt[0][0]}, ({amnt[0][1]})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото ES ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото ES ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif amnt[0][0] == "br_id":
            kol = int(promo_promo[5]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, br_id = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    amnt[0][1],
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/{country[0]}/photo_usr/{user_id}_completed.png",
                    "rb",
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({amnt[0][1]})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif amnt[0][0] == "kz_id_old":
            kol = int(promo_promo[5]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, kz_id_old = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    amnt[0][1],
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/kz/kz_id_old/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({amnt[0][1]})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ ID OLD после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif amnt[0][0] == "ar_pass":
            kol = int(promo_promo[5]) + 1
            cur.execute(
                "UPDATE promo SET sale = ?, ar_pass = ? WHERE name = ?",
                (
                    kol_sale,
                    kol,
                    amnt[0][1],
                ),
            )
            base.commit()
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/ar/ar_pass/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({amnt[0][1]})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ ID OLD после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        else:
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country[0]}_pass/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({amnt[0][1]})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
    else:
        if country[0] == "uk_bill":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/uk_pass/{country[0]}/photo_usr/{user_id}_completed.png",
                    "rb",
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "uk":
            try:
                try:
                    await bot.send_message(user_id, "Фото отправляется, ожидайте")
                    async with aiofiles.open(
                        f"./files/uk_pass/photo_usr/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    await bot.send_message(user_id, "Фото отправляется, ожидайте")
                    async with aiofiles.open(
                        f"./files/uk_pass/photo_usr/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "br_bill":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/{country[0]}/photo_usr/{user_id}_completed.png",
                    "rb",
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "br_id":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/{country[0]}/photo_usr/{user_id}_completed.png",
                    "rb",
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "it_bill":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country[0]}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0], f"Произошла ошибка при отправке фото после покупки"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "mx_pass":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/mx/mx_pass/photo_usr/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/mx/mx_pass/photo_usr/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото MX PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото MX PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country[0] == "mx_bill":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/mx_bill/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0], f"Произошла ошибка при отправке фото после покупки"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "it_id":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country[0]}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "it_dl":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country[0]}/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото DL",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото DL после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "es_pass":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/es/photo_usr/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/es/photo_usr/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото ES PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото ES PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "de_id":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/de_id/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото DE ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото DE ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "est_bill":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/estonia_bill/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото EST BILL",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото EST BILL после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "est_id":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/estonia_id/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото EST ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото EST ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "kz_id_new":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/kz/kz_id_new/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "kz_pass":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/kz/kz_passport/photo_usr/{user_id}_completed.png",
                        "rb",
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/kz/kz_passport/photo_usr/{user_id}_completed.jpg",
                        "rb",
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "ar_id":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/ar/ar_id/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото AR ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото AR ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country[0] == "ar_pass":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/ar/ar_pass/photo_usr/{user_id}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/ar/ar_pass/photo_usr/{user_id}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото AR PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото AR PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
            return
        elif country[0] == "br_pass":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/br_pass/br_passport/photo_usr/{user_id}_completed.jpg",
                        "rb",
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                except:
                    async with aiofiles.open(
                        f"./files/br_pass/br_passport/photo_usr/{user_id}_completed.png",
                        "rb",
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)

            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото BR PASS",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото BR PASS после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "br_dl":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/br_dl/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото BR DL",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото BR DL после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "es_id":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/es/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото ES ID",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото ES ID после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "kz_id_old":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/kz/kz_id_old/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ ID OLD",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ ID OLD после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "de_bill":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/de_bill/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ ID OLD",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ ID OLD после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "ar_pass":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/ar/ar_pass/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ ID OLD",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ ID OLD после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "ar_id":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/ar/ar_id/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ ID OLD",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ ID OLD после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "mx_pass":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/mx/mx_pass/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ ID OLD",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ ID OLD после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "kz_pass":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/kz/kz_pass/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ ID OLD",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ ID OLD после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "kz_id_new":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/kz/kz_id_new/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ ID OLD",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ ID OLD после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        elif country[0] == "kz_id_old":
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/kz/kz_id_old/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото KZ ID OLD",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото KZ ID OLD после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)
        else:
            try:
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country[0]}_pass/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, (промо нет)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except Exception as ex:
                await bot.send_message(
                    user_id,
                    "Произошла ошибка при отправке фото",
                    reply_markup=client_kb.kb_choice,
                )
                logger.exception("Ошибка после покупки при отправке файла:", ex)
                try:
                    await bot.send_message(
                        Admins[0],
                        f"Произошла ошибка при отправке фото паспорта после покупки",
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу2", ex)


async def sql_give_pasp_chip(user_id, country_name, promo_name):
    promo_promo = cur.execute(
        "SELECT sale, ar, uk, uk_bill, mx_pass, mx_bill, br_bill, it_bill, br_id, kz_pass, kz_id_new, kz_id_old, est_id, de_bill, ar_pass, ar_id FROM promo WHERE name = ?",
        (promo_name,),
    ).fetchone()
    kol_sale = int(promo_promo[0]) + 1
    if country_name == "ar":
        kol = int(promo_promo[1]) + 1
        cur.execute(
            "UPDATE promo SET sale = ?, ar = ? WHERE name = ?",
            (
                kol_sale,
                kol,
                promo_name,
            ),
        )
        base.commit()
    elif country_name == "uk":
        kol = int(promo_promo[2]) + 1
        cur.execute(
            "UPDATE promo SET sale = ?, uk = ? WHERE name = ?",
            (
                kol_sale,
                kol,
                promo_name,
            ),
        )
        base.commit()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            try:
                async with aiofiles.open(
                    f"./files/uk_pass/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except:
                async with aiofiles.open(
                    f"./files/uk_pass/photo_usr/{user_id}_completed.jpg", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото паспорта после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "uk_bill":
        kol = int(promo_promo[3]) + 1
        cur.execute(
            "UPDATE promo SET sale = ?, uk_bill = ? WHERE name = ?",
            (
                kol_sale,
                kol,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/uk_pass/{country[0]}/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото паспорта после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "mx_pass":
        cur.execute(
            "UPDATE promo SET sale = ?, mx_pass = mx_pass + 1 WHERE name = ?",
            (
                kol_sale,
                promo_name,
            ),
        )
        base.commit()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            try:
                async with aiofiles.open(
                    f"./files/mx/mx_pass/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except:
                async with aiofiles.open(
                    f"./files/mx/mx_pass/photo_usr/{user_id}_completed.jpg", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото MX PASS",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото MX PASS после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "mx_bill":
        kol = int(promo_promo[3]) + 1
        cur.execute(
            "UPDATE promo SET sale = ?, mx_bill = ? WHERE name = ?",
            (
                kol_sale,
                kol,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/mx_bill/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото паспорта после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "br_bill":
        kol = int(promo_promo[4]) + 1
        cur.execute(
            "UPDATE promo SET sale = ?, br_bill = ? WHERE name = ?",
            (
                kol_sale,
                kol,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/br_pass/{country[0]}/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото паспорта после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "it_bill":
        kol = int(promo_promo[6]) + 1
        cur.execute(
            "UPDATE promo SET sale = ?, it_bill = ? WHERE name = ?",
            (
                kol_sale,
                kol,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/{country[0]}/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "de_bill":
        kol = int(promo_promo[6]) + 1
        cur.execute(
            "UPDATE promo SET sale = ?, de_bill = ? WHERE name = ?",
            (
                kol_sale,
                kol,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/{country[0]}/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "it_id":
        cur.execute(
            "UPDATE promo SET sale = ?, it_id = it_id + 1 WHERE name = ?",
            (
                kol_sale,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/{country_name}/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото ID",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото ID после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "it_dl":
        cur.execute(
            "UPDATE promo SET sale = ?, it_dl = it_dl + 1 WHERE name = ?",
            (
                kol_sale,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/{country_name}/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото DL",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото DL после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "es_pass":
        cur.execute(
            "UPDATE promo SET sale = ?, es_pass = es_pass + 1 WHERE name = ?",
            (
                kol_sale,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            try:
                async with aiofiles.open(
                    f"./files/es/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except:
                async with aiofiles.open(
                    f"./files/es/photo_usr/{user_id}_completed.jpg", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото ES PASS",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото ES PASS после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "de_id":
        cur.execute(
            "UPDATE promo SET sale = ?, de_id = de_id + 1 WHERE name = ?",
            (
                kol_sale,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/de_id/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото DE ID",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото DE ID после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "est_bill":
        cur.execute(
            "UPDATE promo SET sale = ?, est_bill = est_bill + 1 WHERE name = ?",
            (
                kol_sale,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/estonia_bill/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото EST BILL",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото EST BILL после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "est_id":
        cur.execute(
            "UPDATE promo SET sale = ?, est_id = est_id + 1 WHERE name = ?",
            (
                kol_sale,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/estonia_id/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото EST ID",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото EST ID после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "kz_id_new":
        cur.execute(
            "UPDATE promo SET sale = ?, kz_id_new = kz_id_new + 1 WHERE name = ?",
            (
                kol_sale,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/kz/kz_id_new/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото KZ ID",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото KZ ID после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "kz_pass":
        cur.execute(
            "UPDATE promo SET sale = ?, kz_pass = kz_pass + 1 WHERE name = ?",
            (
                kol_sale,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            try:
                async with aiofiles.open(
                    f"./files/kz/kz_passport/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except:
                async with aiofiles.open(
                    f"./files/kz/kz_passport/photo_usr/{user_id}_completed.jpg", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото KZ PASS",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото KZ PASS после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "ar_id":
        cur.execute(
            "UPDATE promo SET sale = ?, ar_id = ar_id + 1 WHERE name = ?",
            (
                kol_sale,
                promo_name,
            ),
        )
        base.commit()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/ar/ar_id/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото AR ID",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото AR ID после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "ar_pass":
        cur.execute(
            "UPDATE promo SET sale = ?, ar_pass = ar_pass + 1 WHERE name = ?",
            (
                kol_sale,
                promo_name,
            ),
        )
        base.commit()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            try:
                async with aiofiles.open(
                    f"./files/ar/ar_pass/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except:
                async with aiofiles.open(
                    f"./files/ar/ar_pass/photo_usr/{user_id}_completed.jpg", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото AR PASS",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото AR PASS после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "br_pass":
        cur.execute(
            "UPDATE promo SET sale = ?, br_pass = br_pass + 1 WHERE name = ?",
            (
                kol_sale,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            try:
                async with aiofiles.open(
                    f"./files/br_pass/br_passport/photo_usr/{user_id}_completed.jpg",
                    "rb",
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except:
                async with aiofiles.open(
                    f"./files/br_pass/br_passport/photo_usr/{user_id}_completed.png",
                    "rb",
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)

        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото BR PASS",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото BR PASS после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "br_dl":
        cur.execute(
            "UPDATE promo SET sale = ?, br_dl = br_dl + 1 WHERE name = ?",
            (
                kol_sale,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/br_pass/br_dl/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото BR DL",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото BR DL после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "es_id":
        cur.execute(
            "UPDATE promo SET sale = ?, es_id = es_id + 1 WHERE name = ?",
            (
                kol_sale,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/es/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото ES ID",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото ES PASS после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "br_id":
        kol = int(promo_promo[5]) + 1
        cur.execute(
            "UPDATE promo SET sale = ?, br_id = ? WHERE name = ?",
            (
                kol_sale,
                kol,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/br_pass/{country[0]}/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото паспорта после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "kz_id_old":
        kol = int(promo_promo[5]) + 1
        cur.execute(
            "UPDATE promo SET sale = ?, kz_id_old = ? WHERE name = ?",
            (
                kol_sale,
                kol,
                promo_name,
            ),
        )
        base.commit()
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/kz/kz_id_old/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото ID после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    else:
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user_id,)
        ).fetchone()
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/{country[0]}_pass/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country[0]}, ({promo_name})"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото паспорта после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)


async def sql_give_pasp_sub(user_id, country_name):
    if country_name == "uk_bill":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/uk_pass/{country_name}/photo_usr/{user_id}_completed.png",
                "rb",
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото паспорта после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "uk":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            try:
                async with aiofiles.open(
                    f"./files/uk_pass/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country_name}, (s)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except:
                async with aiofiles.open(
                    f"./files/uk_pass/photo_usr/{user_id}_completed.jpg", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country_name}, (s)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото паспорта после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "br_bill":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/br_pass/{country_name}/photo_usr/{user_id}_completed.png",
                "rb",
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото паспорта после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "br_id":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/br_pass/{country_name}/photo_usr/{user_id}_completed.png",
                "rb",
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото паспорта после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "it_bill":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/{country_name}/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "de_bill":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/{country_name}/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "mx_pass":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            try:
                async with aiofiles.open(
                    f"./files/mx/mx_pass/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country_name}, (s)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except:
                async with aiofiles.open(
                    f"./files/mx/mx_pass/photo_usr/{user_id}_completed.jpg", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country_name}, (s)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото MX PASS",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото MX PASS после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "mx_bill":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/mx_bill/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "it_id":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/{country_name}/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото ID",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото ID после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "it_dl":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/{country_name}/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото DL",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото DL после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "es_pass":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            try:
                async with aiofiles.open(
                    f"./files/es/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country_name}, (s)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except:
                async with aiofiles.open(
                    f"./files/es/photo_usr/{user_id}_completed.jpg", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country_name}, (s)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото ES PASS",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото ES PASS после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "de_id":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/de_id/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото DE ID",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото DE ID после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "est_bill":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/estonia_bill/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото EST BILL",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото EST BILL после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "est_id":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/estonia_id/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото EST ID",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото EST ID после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "kz_id_new":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/kz/kz_id_new/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото KZ ID",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото KZ ID после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "kz_pass":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            try:
                async with aiofiles.open(
                    f"./files/kz/kz_passport/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country_name}, (s)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except:
                async with aiofiles.open(
                    f"./files/kz/kz_passport/photo_usr/{user_id}_completed.jpg", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country_name}, (s)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото KZ PASS",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото KZ PASS после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "ar_id":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/ar/ar_id/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото AR ID",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото AR ID после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "ar_pass":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            try:
                async with aiofiles.open(
                    f"./files/ar/ar_pass/photo_usr/{user_id}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country_name}, (s)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except:
                async with aiofiles.open(
                    f"./files/ar/ar_pass/photo_usr/{user_id}_completed.jpg", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country_name}, (s)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото AR PASS",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото AR PASS после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
        return
    elif country_name == "br_pass":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            try:
                async with aiofiles.open(
                    f"./files/br_pass/br_passport/photo_usr/{user_id}_completed.jpg",
                    "rb",
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country_name}, (s)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
            except:
                async with aiofiles.open(
                    f"./files/br_pass/br_passport/photo_usr/{user_id}_completed.png",
                    "rb",
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        Admins[0], f"Совершена покупка, {country_name}, (s)"
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)

        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото BR PASS",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото BR PASS после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "br_dl":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/br_pass/br_dl/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото BR DL",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото BR DL после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "es_id":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/es/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото ES ID",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0], f"Произошла ошибка при отправке фото ES ID после покупки"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    elif country_name == "kz_id_old":
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/kz/kz_id_old/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото KZ ID OLD",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото KZ ID OLD после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)
    else:
        try:
            await bot.send_message(user_id, "Фото отправляется, ожидайте")
            async with aiofiles.open(
                f"./files/{country_name}_pass/photo_usr/{user_id}_completed.png", "rb"
            ) as f:
                await bot.send_document(
                    chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                )
            try:
                await bot.send_message(
                    Admins[0], f"Совершена покупка, {country_name}, (s)"
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу", ex)
        except Exception as ex:
            await bot.send_message(
                user_id,
                "Произошла ошибка при отправке фото",
                reply_markup=client_kb.kb_choice,
            )
            logger.exception("Ошибка после покупки при отправке файла:", ex)
            try:
                await bot.send_message(
                    Admins[0],
                    f"Произошла ошибка при отправке фото паспорта после покупки",
                )
            except Exception as ex:
                logger.exception("Ошибка при рассылке админу2", ex)


####admin


async def sql_admin_command(user_id):
    all_user = cur.execute("SELECT * FROM users").fetchall()
    await bot.send_message(
        user_id,
        f"Количество запустивших бота: {len(all_user)}",
        reply_markup=admin_kb.admin_menu,
    )


async def sql_command_give_acc_go(state, message, user):
    user_id = message.from_user.id
    try:
        country = cur.execute(
            "SELECT country FROM 'users' WHERE id = ?", (user,)
        ).fetchone()
        if country[0] is None:
            await bot.send_message(
                user_id,
                f"У данного юзера нет готовых для выдачи документов",
                reply_markup=admin_kb.admin_menu,
            )
            await state.finish()
        else:
            if country[0] == "uk_bill":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/uk_pass/{country[0]}/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "uk":
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/uk_pass/photo_usr/{user}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user, document=f, reply_markup=client_kb.kb_choice
                        )
                    try:
                        await bot.send_message(
                            user_id,
                            f"фото отправлено",
                            reply_markup=admin_kb.admin_menu,
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                    await state.finish()
                except:
                    async with aiofiles.open(
                        f"./files/uk_pass/photo_usr/{user}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user, document=f, reply_markup=client_kb.kb_choice
                        )
                    try:
                        await bot.send_message(
                            user_id,
                            f"фото отправлено",
                            reply_markup=admin_kb.admin_menu,
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                    await state.finish()
            elif country[0] == "br_bill":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/{country[0]}/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "br_id":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/{country[0]}/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "it_bill":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country[0]}/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()

            elif country[0] == "de_bill":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country[0]}/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "mx_pass":
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/mx/mx_pass/photo_usr/{user}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user, document=f, reply_markup=client_kb.kb_choice
                        )
                    try:
                        await bot.send_message(
                            user_id,
                            f"фото отправлено",
                            reply_markup=admin_kb.admin_menu,
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                    await state.finish()
                except:
                    async with aiofiles.open(
                        f"./files/mx/mx_pass/photo_usr/{user}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user, document=f, reply_markup=client_kb.kb_choice
                        )
                    try:
                        await bot.send_message(
                            user_id,
                            f"фото отправлено",
                            reply_markup=admin_kb.admin_menu,
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                    await state.finish()
            elif country[0] == "mx_bill":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/mx_bill/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "it_id":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country[0]}/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "it_dl":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country[0]}/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "es_pass":
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/es/photo_usr/{user}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            user_id,
                            f"фото отправлено",
                            reply_markup=admin_kb.admin_menu,
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                    await state.finish()
                except:
                    async with aiofiles.open(
                        f"./files/es/photo_usr/{user}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            user_id,
                            f"фото отправлено",
                            reply_markup=admin_kb.admin_menu,
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                    await state.finish()
            elif country[0] == "de_id":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/de_id/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "est_bill":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/estonia_bill/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "de_bill":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/de_bill/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "est_id":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/estonia_id/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "kz_id_new":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/kz/kz_id_new/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "kz_pass":
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/kz/kz_passport/photo_usr/{user}_completed.png", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            user_id,
                            f"фото отправлено",
                            reply_markup=admin_kb.admin_menu,
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                    await state.finish()
                except:
                    async with aiofiles.open(
                        f"./files/kz/kz_passport/photo_usr/{user}_completed.jpg", "rb"
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            user_id,
                            f"фото отправлено",
                            reply_markup=admin_kb.admin_menu,
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                    await state.finish()
            elif country[0] == "br_pass":
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                try:
                    async with aiofiles.open(
                        f"./files/br_pass/br_passport/photo_usr/{user}_completed.png",
                        "rb",
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            user_id,
                            f"фото отправлено",
                            reply_markup=admin_kb.admin_menu,
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                    await state.finish()
                except:
                    async with aiofiles.open(
                        f"./files/br_pass/br_passport/photo_usr/{user}_completed.jpg",
                        "rb",
                    ) as f:
                        await bot.send_document(
                            chat_id=user_id,
                            document=f,
                            reply_markup=client_kb.kb_choice,
                        )
                    try:
                        await bot.send_message(
                            user_id,
                            f"фото отправлено",
                            reply_markup=admin_kb.admin_menu,
                        )
                    except Exception as ex:
                        logger.exception("Ошибка при рассылке админу", ex)
                    await state.finish()
            elif country[0] == "br_dl":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/br_pass/br_dl/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "es_id":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/es/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "kz_id_old":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/kz/kz_id_old/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "de_bill":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/de_bill/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            elif country[0] == "ar_pass":
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/ar/ar_pass/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user_id, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
            else:
                await bot.send_message(user, "Фото отправляется, ожидайте")
                await bot.send_message(user_id, "Фото отправляется, ожидайте")
                async with aiofiles.open(
                    f"./files/{country[0]}_pass/photo_usr/{user}_completed.png", "rb"
                ) as f:
                    await bot.send_document(
                        chat_id=user, document=f, reply_markup=client_kb.kb_choice
                    )
                try:
                    await bot.send_message(
                        user_id, f"фото отправлено", reply_markup=admin_kb.admin_menu
                    )
                except Exception as ex:
                    logger.exception("Ошибка при рассылке админу", ex)
                await state.finish()
    except Exception as ex:
        logger.exception("Ошибка при выдаче доков вручную", ex)
        await bot.send_message(
            user_id,
            f"Что-то пошло не так, вероятно этот пользователь "
            f"не запустил бота либо заблокировал",
            reply_markup=admin_kb.admin_menu,
        )
        await state.finish()


async def sql_admin_promo(message):
    user_id = message.from_user.id
    all_promo = cur.execute("SELECT * FROM promo").fetchall()
    text = f"Ниже действующие промокоды:\n\n"
    logger.info(all_promo)
    for i in all_promo:
        text += (
            f"{i[0]}) {i[1]} - {i[2]} % (покупок: {i[3]}, arg: {i[4]}, uk: {i[5]}, uk_bill: {i[6]}, "
            f"br_bill: {i[7]}, br_id: {i[8]}, it_bill: {i[9]}, it_id: {i[10]}, it_dl: {i[12]}, mx_id: {i[11]}, es_pass: {i[13]}, es_id: {i[14]}, br_dl: {i[15]}, br_passport: {i[16]}, kz_pass: {i[17]}, kz_id_new: {i[18]}, kz_id_old: {i[19]}, est_id: {i[20]}, de_bill: {i[21]}, ar_pass: {i[22]}, ar_id: {i[23]}, est_bill: {i[24]}, de_id: {i[25]}, mx_pass: {i[26]})\n"
        )
    await bot.send_message(user_id, f"{text}", reply_markup=admin_kb.kb_promo_admin)


async def sql_admin_add_promo(message, state):
    user_id = message.from_user.id
    try:
        async with state.proxy() as data:
            promo = tuple(data.values())
        cur.execute(
            "INSERT INTO 'promo' ('name', 'discount') VALUES (?,?)",
            (promo[0], promo[1]),
        )
        base.commit()
        await bot.send_message(
            user_id, f"Промокод добавлен", reply_markup=admin_kb.admin_menu
        )
        await state.finish()
        await sql_admin_promo(message)
    except Exception as ex:
        await bot.send_message(
            user_id, f"Ошибка:\n {ex}", reply_markup=admin_kb.admin_menu
        )
        await state.finish()


async def sql_admin_delete_promo(message, state, promo_del):
    user_id = message.from_user.id
    all_promo = cur.execute(
        "SELECT * FROM promo WHERE id = ?", (int(promo_del),)
    ).fetchone()
    if all_promo is None:
        await bot.send_message(
            user_id,
            f"Промокода под таким id нет в БД",
            reply_markup=admin_kb.admin_menu,
        )
        await state.finish()
    else:
        cur.execute("DELETE FROM promo WHERE id = ?", (int(promo_del),))
        base.commit()
        await bot.send_message(
            user_id, f"Промокод успешно удален", reply_markup=admin_kb.admin_menu
        )
        await state.finish()
        await sql_admin_promo(message)


async def sql_admin_mail_sendind(
    user_id, mime_check, mail_doc_file_id, caption, entities
):
    users = cur.execute("SELECT id FROM users WHERE id != ?", (user_id,)).fetchall()
    if (mime_check.split("/", 1)[0]) == "video":
        a = 0
        for user in users:
            try:
                await bot.send_animation(
                    chat_id=user[0],
                    animation=f"{mail_doc_file_id}",
                    caption=f"{caption}",
                    caption_entities=entities,
                )
                a = a + 1
            except:
                pass
        await bot.send_message(user_id, f"Рассылка завершена.\n" f"Получили: {a}\n")

    elif (mime_check.split("/", 1)[0]) == "just_photo":
        a = 0
        for user in users:
            try:
                await bot.send_photo(
                    chat_id=user[0],
                    photo=f"{mail_doc_file_id}",
                    caption=f"{caption}",
                    caption_entities=entities,
                )
                a = a + 1
            except:
                pass
        await bot.send_message(user_id, f"Рассылка завершена.\n" f"Получили: {a}\n")

    elif (mime_check.split("/", 1)[0]) == "text":
        a = 0
        for user in users:
            try:
                await bot.send_message(
                    chat_id=user[0], text=f"{caption}", entities=entities
                )
                a = a + 1
            except:
                pass
        await bot.send_message(user_id, f"Рассылка завершена.\n" f"Получили: {a}\n")


########################################################


# async def sql_checkk(user_id):
# result = cur.execute("SELECT * FROM 'CHECK' WHERE user_id = ?", (user_id,)).fetchall()
# bill = result[-1][1]
# await sql_give_acc(user_id, bill)
